// node script/extract_skills_from_data1.js
const fs = require('fs');
const path = require('path');

// 源文件路径
const sourceFile = path.join(__dirname, 'data', 'skill_data.js');
// 目标目录
const targetDirs = {
    physical: path.join(__dirname, 'skills', 'ad'),
    magic: path.join(__dirname, 'skills', 'ap'),
    status: path.join(__dirname, 'skills', 'status'),
    buff: path.join(__dirname, 'skills', 'buff'),
    debuff: path.join(__dirname, 'skills', 'debuff'),
    fb: path.join(__dirname, 'skills', 'fbs'),
    regen: path.join(__dirname, 'skills', 'regen'),
    seal: path.join(__dirname, 'skills', 'seal'),
    final: path.join(__dirname, 'skills', 'final'),
    sq: path.join(__dirname, 'skills', 'sq'),
    item: path.join(__dirname, 'skills', 'item'),
    other: path.join(__dirname, 'skills', 'other')
};

// 确保所有目录存在
Object.values(targetDirs).forEach(dir => {
    if (!fs.existsSync(dir)) {
        fs.mkdirSync(dir, { recursive: true });
    }
});

// 读取源文件内容
const content = fs.readFileSync(sourceFile, 'utf8');

// 获取指定目录的最大文件数字
function getMaxFileNumber(dir) {
    if (!fs.existsSync(dir)) return 0;

    const files = fs.readdirSync(dir);
    let maxNum = 0;

    files.forEach(file => {
        const match = file.match(/^(\d+)\.js$/);
        if (match) {
            const num = parseInt(match[1], 10);
            if (num > maxNum) {
                maxNum = num;
            }
        }
    });

    return maxNum;
}

// 从技能内容中提取类型
function getSkillType(skillContent) {
    // 查找 "技能类型": "xxx" 的模式
    const typeMatch = skillContent.match(/"技能类型"\s*:\s*"([^"]+)"/);
    if (typeMatch) {
        const type = typeMatch[1];
        if (type === '物理') {
            return 'physical';
        } else if (type === '法术') {
            return 'magic';
        } else if (type === '增益') {
            return 'buff';
        } else if (type === '减益') {
            return 'debuff';
        } else if (type === '法宝') {
            return 'fb';
        } else if (type === '恢复') {
            return 'regen';
        } else if (type === '单封' || type === '群封') {
            return 'seal';
        } else if (type === '固伤') {
            return 'final';
        } else if (type === '神器') {
            return 'sq';
        } else if (type === '道具') {
            return 'item';
        }
    }
    return 'other';
}

// 提取每个key的内容
function extractSkills() {
    const skills = [];

    // 移除export default和包裹的大括号
    let cleanContent = content.replace(/export\s+default\s*{/, '').replace(/}\s*$/, '');

    // 使用精确的分割方法，确保开头是固定空格
    // 匹配以空格开头的 "xxx": { 格式
    const skillStarts = [...cleanContent.matchAll(/^(\s+)"([^"]+)":\s*{/gm)];

    for (let i = 0; i < skillStarts.length; i++) {
        const skillName = skillStarts[i][2];
        let startPos = skillStarts[i].index;

        let endPos;
        if (i < skillStarts.length - 1) {
            // 不是最后一个技能，找到下一个技能的起始位置
            endPos = skillStarts[i + 1].index;
        } else {
            // 最后一个技能，找到文件末尾
            endPos = cleanContent.length;
        }

        // 提取完整的技能定义
        let skillText = cleanContent.substring(startPos, endPos).trim();

        // 将内容按行分割
        let lines = skillText.split('\n');

        // 从结尾开始向上检查，删除注释行
        let cleanLines = [];
        let foundEnd = false;

        for (let j = lines.length - 1; j >= 0; j--) {
            let line = lines[j].trim();

            if (!foundEnd) {
                // 还在寻找结尾
                if (line === '},') {
                    // 找到结尾，改为 }
                    cleanLines.unshift('}');
                    foundEnd = true;
                } else if (line === '}') {
                    // 已经是正确的结尾
                    cleanLines.unshift('}');
                    foundEnd = true;
                } else if (!line.startsWith('//') && line !== '') {
                    // 不是注释也不是空行，保留
                    cleanLines.unshift(lines[j]);
                }
                // 如果是注释行或空行，则跳过（删除）
            } else {
                // 已经找到结尾，保留剩余内容
                cleanLines.unshift(lines[j]);
            }
        }

        // 重新组合清理后的内容
        let finalSkillContent = cleanLines.join('\n');

        // 提取类型
        const skillType = getSkillType(finalSkillContent);

        skills.push({
            name: skillName,
            content: finalSkillContent,
            type: skillType
        });
    }

    return skills;
}

// 格式化代码的函数
function formatCode(content) {
    // 使用更智能的格式化
    let lines = content.split('\n');
    let formattedLines = [];
    let indentLevel = 0;
    const indentSize = 4;

    for (let line of lines) {
        line = line.trim();
        if (!line) continue;

        // 减少缩进的情况
        if (line.includes('}') && !line.includes('{')) {
            indentLevel = Math.max(0, indentLevel - 1);
        }

        // 添加缩进
        let indent = ' '.repeat(indentLevel * indentSize);
        formattedLines.push(indent + line);

        // 增加缩进的情况
        if (line.includes('{') && !line.includes('}')) {
            indentLevel++;
        }
    }

    return formattedLines.join('\n');
}

// 创建新文件
function createSkillFiles() {
    const skills = extractSkills();

    console.log(`找到 ${skills.length} 个技能`);

    // 按类型统计
    const typeCounts = {
    };

    skills.forEach((skill, index) => {
        const targetDir = targetDirs[skill.type];
        const maxNum = getMaxFileNumber(targetDir);
        const fileNumber = maxNum + 1;
        const fileName = `${fileNumber}.js`;
        const filePath = path.join(targetDir, fileName);

        // 构建文件内容
        let skillContent = skill.content;

        // 在对象中添加"名称"字段
        let modifiedContent = skillContent.replace(/"([^"]+)":\s*{/, `{\n    "名称": "$1",`);

        // 创建完整的模块内容
        let finalContent = `export default ${modifiedContent};`;

        // 格式化内容
        finalContent = formatCode(finalContent);

        // 写入文件
        fs.writeFileSync(filePath, finalContent);
        if (typeCounts[skill.type] === undefined) {
            typeCounts[skill.type] = 0;
        }
        typeCounts[skill.type]++;
        console.log(`已创建: ${fileName} (${skill.name}) -> ${skill.type} 目录`);
    });

    console.log(`完成！共创建了 ${skills.length} 个文件`);
    console.log(`分类统计：`);
    for (const key in typeCounts) {
        console.log(`- ${key}: ${typeCounts[key]} 个`);
    }
}

// 执行提取
try {
    createSkillFiles();
} catch (error) {
    console.error('执行过程中出现错误:', error);
    console.error(error.stack);
}
